﻿using System;

namespace SeeSharpTools.JY.Socket.ValueHelper
{

    public class LittleEndianValueHelper
    {
        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的 16 位有符号整数值。
        /// </summary>
        /// <param name="value"> 要转换的数字。</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(short value)
        {
            return BitConverter.GetBytes(value);
        }
        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的 16 位有符号整数数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(short[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(BitConverter.GetBytes(value[i]), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }

        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的 32 位有符号整数的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(int value)
        {
            return BitConverter.GetBytes(value);
        }
        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的 32 位有符号整数数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(int[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(BitConverter.GetBytes(value[i]), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }

        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的单精度浮点值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(float value)
        {
            return BitConverter.GetBytes(value);
        }
        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的单精度浮点数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(float[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(BitConverter.GetBytes(value[i]), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }


        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的双精度浮点值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(double value)
        {
            return BitConverter.GetBytes(value);
        }

        /// <summary>
        /// 小端读取的模式，以字节数组的形式返回指定的双精度浮点数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(double[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(BitConverter.GetBytes(value[i]), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }

        /// <summary>
        /// 小端读取的模式，返回由字节数组中指定位置的两个字节转换来的 16 位有符号整数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的16位有符号整数</returns>
        public static short GetShort(byte[] data)
        {
            return BitConverter.ToInt16(data, 0);
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组转换来的 16 位有符号整数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的16位有符号整数数组</returns>
        public static short[] GetShortArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((short)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            short[] TempShort = new short[data.Length / CntBytes];
            for (int i = 0; i < TempShort.Length; i++)
            {
                TempShort[i] = BitConverter.ToInt16(data, 0 + i * CntBytes);
            }
            return TempShort;
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组中指定位置的四个字节转换来的 32 位有符号整数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的32位有符号整数</returns>
        public static int GetInt(byte[] data)
        {
            return BitConverter.ToInt32(data, 0);
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组转换来的 32 位有符号整数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的32位有符号整数数组</returns>
        public static int[] GetIntArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((int)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            int[] TempInt = new int[data.Length / CntBytes];
            for (int i = 0; i < TempInt.Length; i++)
            {
                TempInt[i] = BitConverter.ToInt32(data, 0 + i * CntBytes);
            }
            return TempInt;
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组中指定位置的四个字节转换来的单精度浮点数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的单精度浮点数</returns>
        public static float GetFloat(byte[] data)
        {
            return BitConverter.ToSingle(data, 0);
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数转换来的单精度浮点数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的单精度浮点数数组</returns>
        public static float[] GetFloatArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((float)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            float[] TempFloat = new float[data.Length / CntBytes];
            for (int i = 0; i < TempFloat.Length; i++)
            {
                TempFloat[i] = BitConverter.ToSingle(data, 0 + i * CntBytes);
            }
            return TempFloat;
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组中指定位置的八个字节转换来的双精度浮点数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的双精度浮点数</returns>
        public static double GetDouble(byte[] data)
        {
            return BitConverter.ToDouble(data, 0);
        }
        /// <summary>
        /// 小端读取的模式，返回由字节数组转换来的双精度浮点数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的双精度浮点数数组</returns>
        public static double[] GetDoubleArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((double)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            double[] TempDouble = new double[data.Length / CntBytes];
            for (int i = 0; i < TempDouble.Length; i++)
            {
                TempDouble[i] = BitConverter.ToDouble(data, 0 + i * CntBytes);
            }
            return TempDouble;
        }
    }


    public class BigEndianValueHelper
    {
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的 16 位有符号整数值。
        /// </summary>
        /// <param name="value"> 要转换的数字。</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(short value)
        {
            return Reverse(BitConverter.GetBytes(value));
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的 16 位有符号整数数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(short[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(Reverse(BitConverter.GetBytes(value[i])), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的 32 位有符号整数的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(int value)
        {
            return Reverse(BitConverter.GetBytes(value));
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的 32 位有符号整数数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(int[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(Reverse(BitConverter.GetBytes(value[i])), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的单精度浮点值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(float value)
        {
            return Reverse(BitConverter.GetBytes(value));
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的单精度浮点数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(float[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(Reverse(BitConverter.GetBytes(value[i])), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的双精度浮点值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static Byte[] GetBytes(double value)
        {
            return Reverse(BitConverter.GetBytes(value));
        }
        /// <summary>
        /// 大端读取的模式，以字节数组的形式返回指定的双精度浮点数组的值。
        /// </summary>
        /// <param name="value">要转换的数字</param>
        /// <returns>转化完成的字节数组</returns>
        public static byte[] GetBytes(double[] value)
        {
            int CntBytes = BitConverter.GetBytes(value[0]).Length;
            byte[] TempBytes = new byte[CntBytes * value.Length];

            for (int i = 0; i < value.Length; i++)
            {
                Buffer.BlockCopy(Reverse(BitConverter.GetBytes(value[i])), 0, TempBytes, i * CntBytes, CntBytes);
            }
            return TempBytes;
        }
        /// <summary>
        /// 大端读取的模式，返回由字节数组中指定位置的两个字节转换来的 16 位有符号整数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的16位有符号整数</returns>
        public static short GetShort(byte[] data)
        {
            return BitConverter.ToInt16(Reverse(data), 0);
        }

        /// <summary>
        /// 大端读取的模式，返回由字节数组转换来的 16 位有符号整数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的16位有符号整数数组</returns>
        public static short[] GetShortArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((short)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            short[] TempShort = new short[data.Length / CntBytes];
            byte[] TempByte = new byte[CntBytes];
            for (int i = 0; i < TempShort.Length; i++)
            {
                Buffer.BlockCopy(data, i * CntBytes, TempByte, 0, CntBytes);

                TempShort[i] = BitConverter.ToInt16(Reverse(TempByte), 0);
            }
            return TempShort;
        }
        /// <summary>
        /// 大端读取的模式，返回由字节数组中指定位置的四个字节转换来的 32 位有符号整数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的32位有符号整数</returns>
        public static int GetInt(byte[] data)
        {
            return BitConverter.ToInt32(Reverse(data), 0);
        }

        /// <summary>
        /// 大端读取的模式，返回由字节数组转换来的 32 位有符号整数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的32位有符号整数数组</returns>
        public static int[] GetIntArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((int)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            int[] TempInt = new int[data.Length / CntBytes];
            byte[] TempByte = new byte[CntBytes];
            for (int i = 0; i < TempInt.Length; i++)
            {
                Buffer.BlockCopy(data, i * CntBytes, TempByte, 0, CntBytes);

                TempInt[i] = BitConverter.ToInt32(Reverse(TempByte), 0);
            }
            return TempInt;
        }
        /// <summary>
        /// 大端读取的模式，返回由字节数组中指定位置的四个字节转换来的单精度浮点数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的单精度浮点数</returns>
        public static float GetFloat(byte[] data)
        {
            return BitConverter.ToSingle(Reverse(data), 0);
        }

        /// <summary>
        /// 大端读取的模式，返回由字节数转换来的单精度浮点数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的单精度浮点数数组</returns>
        public static float[] GetFloatArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((float)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            float[] TempFloat = new float[data.Length / CntBytes];
            byte[] TempByte = new byte[CntBytes];
            for (int i = 0; i < TempFloat.Length; i++)
            {
                Buffer.BlockCopy(data, i * CntBytes, TempByte, 0, CntBytes);

                TempFloat[i] = BitConverter.ToSingle(Reverse(TempByte), 0);
            }
            return TempFloat;
        }
        /// <summary>
        /// 大端读取的模式，返回由字节数组中指定位置的八个字节转换来的双精度浮点数。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的双精度浮点数</returns>
        public static double GetDouble(byte[] data)
        {
            return BitConverter.ToDouble(Reverse(data), 0);
        }

        /// <summary>
        /// 大端读取的模式，返回由字节数组转换来的双精度浮点数数组。
        /// </summary>
        /// <param name="value">字节数组</param>
        /// <returns>转化完成的双精度浮点数数组</returns>
        public static double[] GetDoubleArray(byte[] data)
        {
            int CntBytes = BitConverter.GetBytes((double)0).Length;
            if (data.Length % CntBytes != 0)
            {
                return null;
            }
            double[] TempDouble = new double[data.Length / CntBytes];
            byte[] TempByte = new byte[CntBytes];
            for (int i = 0; i < TempDouble.Length; i++)
            {
                Buffer.BlockCopy(data, i * CntBytes, TempByte, 0, CntBytes);

                TempDouble[i] = BitConverter.ToDouble(Reverse(TempByte), 0);
            }
            return TempDouble;
        }

        private static Byte[] Reverse(Byte[] data)
        {
            Array.Reverse(data);
            return data;
        }
    }

}
